package com.jt.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jt.mapper.ItemCatMapper;
import com.jt.pojo.ItemCat;
import com.jt.pojo.Rights;
import com.jt.vo.SysResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.security.PublicKey;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class ItemCatServiceImpl implements ItemCatService{

    @Autowired
   private ItemCatMapper itemCatMapper;
    /*
     * 3层商品分类嵌套 1级children（二级的）
     *               2级children（三级的）
     *
     * 这样的嵌套导致运行速度慢。需要优化，在于我们的数据库的查询语句，查询速度太慢
     *
     * 设计：
     *   1.查询数据库中的所有数据信息
     *   2. key：parentId  value： 当前parentId下子集map 集合
     *   3.将查询的结果封装到map集合中去
     *   4.通过key就能获得数据
     *
     * */
     //定义map集合来保存查询的数据.只查询一次就可以多次使用，提高效率
     public Map<Integer ,List<ItemCat>> itemCatMap(){
         //1.定义map集合
         Map<Integer ,List<ItemCat>> map=new HashMap<>();
        /* //查询所有的数据信息1.2.3
        *    封装业务说明
        * map中的key ---parentId
        * 不存在：可以存储key，同事封装一个list集合，将自己作为第一个元素封装到里面去
        * 存在：根据key获取所有子集集合。将自己追加进去，形成第二个元素
         */
         List<ItemCat> list=itemCatMapper.selectList(null);

         for (ItemCat itemCat:list){

             int parentId=itemCat.getParentId();

             if (map.containsKey(parentId)) {
                 //有key 则把数据插入到对应的key的value里面去
                 List<ItemCat> exeList=map.get(parentId);
                 exeList.add(itemCat);

             }else {
                 //没有key
              List<ItemCat> fristList=new ArrayList<>();
                fristList.add(itemCat);
                map.put(parentId, fristList);

             }
         }
       return map;
     }

    @Override
    public List<ItemCat> findItemCatList(Integer level) {
      /*1.准备一个map的集合，实现数据封装
      * map<parentId, list<ItemCat> >
       */
        //查看运行时间
        long st=System.currentTimeMillis();
        Map<Integer,List<ItemCat>> map = itemCatMap();
        //1.如果level=1.获取一级商品分类信息

        if (level == 1) {
            return map.get(0);
        }

        if (level == 2) {
            return getTwoList(map);
        }


      //返回三级目录的数据结构
        List<ItemCat> oneList=getTwoList(map);

        for (ItemCat twolist: oneList ){
            //从一级目录中，获取二级目录
            List<ItemCat> twoList=twolist.getChildren();
            //防止我们的前端查询的页面，因为他查不到一级和二级的目录，不写的话，后台会报空指针异常

            if (twoList == null||twoList.size()==0) {
                continue;
            }

            for (ItemCat twoItem:twoList){
                //从二级目录中获取三级目录
                List<ItemCat> threelist=map.get(twoItem.getId());
               twoItem.setChildren(threelist);
            }
        }
       long ed=System.currentTimeMillis();
        System.out.println("运行的时间是："+ (ed-st));
           return oneList;

    }
//根据id修改用户状态
    @Override
    @Transactional
    public void updateStatus(ItemCat itemCat) {

         itemCatMapper.updateById(itemCat);
    }

    @Override
    @Transactional
    public void addItem(ItemCat itemCat) {

         itemCat.setStatus(true);
        itemCatMapper.insert(itemCat);
    }

    @Override
    @Transactional
    public void updateItemCat(ItemCat itemCat) {

         itemCatMapper.updateById(itemCat);
    }

    @Override
    @Transactional
    public void deleteItemCat(ItemCat itemCat) {
        //判断level的级别
         if (itemCat.getLevel() == 3) {
            itemCatMapper.deleteById(itemCat);
            return;//程序终止
        }

        if (itemCat.getLevel() == 2) {
            QueryWrapper queryWrapper=new QueryWrapper();
            queryWrapper.eq("parent_id", itemCat.getId());
            //先删三级
             itemCatMapper.delete(queryWrapper);
           //再删二级
             itemCatMapper.deleteById(itemCat.getId());
             return;

        }

             QueryWrapper queryWrapper=new QueryWrapper();
             queryWrapper.eq("parent_id", itemCat.getId());

           List<ItemCat> two=itemCatMapper.selectList(queryWrapper);

            for (ItemCat twoItem :two) {
              queryWrapper.clear();
              queryWrapper.eq("parent_id", twoItem.getId());
             itemCatMapper.delete(queryWrapper);
             itemCatMapper.deleteById(twoItem.getId());

            }
          itemCatMapper.deleteById(itemCat.getId());
      }


    //定义我们的二级目录数据的查询
    public  List<ItemCat> getTwoList(Map<Integer,List<ItemCat>> map){

        List<ItemCat> oneList=map.get(0);
        for (ItemCat oneItemCat  :oneList){
            List<ItemCat> twoList=map.get(oneItemCat.getId());
            oneItemCat.setChildren(twoList);

        }
        //返回一级的数据
        return  oneList;

    }


    /*@Override
    public List<ItemCat> findItemCatList( Integer level) {
        //查一级的商品信息
       long startTime=System.currentTimeMillis();
        QueryWrapper queryWrapper=new QueryWrapper();
        queryWrapper.eq("parent_id",0);
        List<ItemCat> oneList=itemCatMapper.selectList(queryWrapper);
        //二级商品信息
          for (ItemCat one : oneList){
            queryWrapper.clear();
            queryWrapper.eq("parent_id",one.getId());

          List<ItemCat> twoList=itemCatMapper.selectList(queryWrapper);
            //三级商品信息
            for (ItemCat two : twoList){
                queryWrapper.clear();
                queryWrapper.eq("parent_id",two.getId());

                List<ItemCat> threeList=itemCatMapper.selectList(queryWrapper);
                two.setChildren(threeList);
            }

            one.setChildren(twoList);

        }
        long endTime=System.currentTimeMillis();
          //返回一级数据信息。里面包含二，三级商品信息
        System.out.println("运行时间："+(endTime-startTime));
        return oneList;
    }*/
}
